home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ded / subr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1984-05-02  |  6.5 KB  |  334 lines
  1. #ifndef lint
  2. static char RCSid[] =
  3. "$Header: subr.c,v 1.3 84/05/01 18:16:12 lepreau Exp $";
  4. #endif
  5.  
  6. /*
  7.  * Miscellaneous functions. Currently (almost) none of them
  8.  * reference any globals.
  9.  */
  10. #include <stdio.h>
  11. #include <ctype.h>
  12. #include <sys/param.h>
  13. #include <sys/stat.h>
  14.  
  15. #include "ded.h"
  16.  
  17. extern int nprint;
  18. extern int errno;
  19.  
  20.     /* this needs cleaning up */
  21. rm(arg)
  22. char *arg;
  23. {
  24.     struct stat buf;
  25.  
  26.     if (lstat(arg, &buf)) {
  27.     printf("%s not deleted.\n", arg);
  28.     return;
  29.     }
  30.     if ((buf.st_mode & S_IFMT) == S_IFDIR) {
  31.     if (access(arg, 02) < 0) {
  32.         printf("%s not deleted.\n", arg);
  33.         return;
  34.     }
  35.     rmrf(arg);
  36.     return;
  37.     }
  38.  
  39.     if (unlink(arg))
  40.     printf("%s not deleted.\n", arg);
  41. }
  42.  
  43. rmrf(f)
  44. char   *f;
  45. {
  46.     int        status,
  47.         pid,
  48.         i;
  49.  
  50.     if (dotname(f))
  51.     return 0;
  52.     while ((pid = vfork()) == -1)
  53.     sleep(3);
  54.     if (pid == 0) {
  55.         execl("/bin/rm", "rm", "-rf", f, (char *) 0);
  56.         execl("/usr/bin/rm", "rm", "-rf", f, (char *) 0);
  57.         printf("Can't find rm\n");
  58.         _exit(1);
  59.     }
  60.     while ((i = wait(&status)) != pid && i != -1)
  61.     continue;
  62. }
  63.  
  64. int
  65. dotname(s)
  66. char   *s;
  67. {
  68.     if (s[0] == '.')
  69.     if (s[1] == '.')
  70.         if (s[2] == '\0')
  71.         return 1;
  72.         else
  73.         return 0;
  74.     else if (s[1] == '\0')
  75.         return 1;
  76.     return 0;
  77. }
  78.  
  79. int    m1[] = {1, S_IREAD >> 0, 'r', '-'};
  80. int    m2[] = {1, S_IWRITE >> 0, 'w', '-'};
  81. int    m3[] = {2, S_ISUID, 's', S_IEXEC >> 0, 'x', '-'};
  82. int    m4[] = {1, S_IREAD >> 3, 'r', '-'};
  83. int    m5[] = {1, S_IWRITE >> 3, 'w', '-'};
  84. int    m6[] = {2, S_ISGID, 's', S_IEXEC >> 3, 'x', '-'};
  85. int    m7[] = {1, S_IREAD >> 6, 'r', '-'};
  86. int    m8[] = {1, S_IWRITE >> 6, 'w', '-'};
  87. int    m9[] = {2, S_ISVTX, 't', S_IEXEC >> 6, 'x', '-'};
  88. int    *m[] =  {m1, m2, m3, m4, m5, m6, m7, m8, m9};
  89. int    flags;            /* Gets flags */
  90.  
  91. pmode(aflag)
  92. {
  93.     register int  **mp;
  94.  
  95.     flags = aflag;
  96.     for (mp = &m[0]; mp < &m[sizeof (m) / sizeof (m[0])];)
  97.     mselect(*mp++);
  98.     
  99. }
  100.  
  101. mselect(pairp)
  102. register int *pairp;
  103. {
  104.     register int n;
  105.  
  106.     n = *pairp++;
  107.     while (--n >= 0 && (flags & *pairp++) == 0)
  108.     pairp++;
  109.     (void) putchar(*pairp);
  110.     nprint++;
  111. }
  112.  
  113. outch(c)
  114. {
  115.     (void) putchar(c);
  116. }
  117.  
  118. putpad(str)
  119. char   *str;
  120. {
  121.     if (str)
  122.     tputs(str, 0, outch);
  123. }
  124.  
  125. /* 
  126.  * Print a filename intelligently.
  127.  * lp        ptr to the lbuf entry
  128.  * maxprt    max number of chars allowed to print
  129.  * typeflg    display the file's type symbolically by appending *, /, @, >
  130.  * symexpand    interpret symbolic links via the src -> target notation
  131.  */
  132. pname(lp, maxprt, typeflg, symexpand)
  133. struct lbuf *lp;
  134. {
  135.     register char *p, *q;
  136.     register int i;
  137.     register int len;
  138.     char buf[MAXPATHLEN];
  139.     char buf2[MAXPATHLEN];
  140.     int truncflg;
  141.     int nprt;
  142.     static struct target nulltarg = {0, ""};
  143.     int expanded = 0;
  144.  
  145.     for (p = lp->namep, q = buf; *p; p++, q++)
  146.         if (isprint(*p))
  147.         *q = *p;
  148.     else
  149.         *q = '?';
  150.     *q = '\0';
  151.  
  152.     truncflg = (lp->namlen + typeflg) > maxprt;
  153.     printf("%.*s%s", maxprt - truncflg - typeflg, buf, truncflg ? "-" : "");
  154.  
  155. #ifdef S_IFLNK
  156.     if (!truncflg && symexpand && (lp->ltype == 'l' || lp->ltype == 'L')) {
  157.     if (!(lp->flg & RDLINKDONE)) {
  158.         buf[0] = '\0';
  159.         (void) bldnam(buf, -1, lp);
  160.         if ((len = readlink(buf, buf2, sizeof buf2)) < 0) {
  161.         (void) sprintf(buf2, "ERRNO%3d", errno);
  162.         len = 8;
  163.         }
  164.         buf2[len] = '\0';
  165.         if ((lp->linkto = (struct target *)
  166.           malloc((unsigned) (sizeof linklen(lp) + len + 1))) == NULL) {
  167.         telluser("Out of memory, not expanding symlink %s",lp->namep);
  168.         lp->linkto = &nulltarg;
  169.         }
  170.         else {
  171.         bcopy(buf2, linkname(lp), len+1);
  172.         linklen(lp) = len;
  173.         }
  174.         lp->flg |= RDLINKDONE;
  175.     }
  176.     if (lp->linkto != &nulltarg) {        /* means was out of mem */
  177.         /* nprt will == how many printed so far */
  178.         nprt = min(lp->namlen, maxprt);
  179.         len = linklen(lp);
  180.         truncflg = (nprt + 4 + len + typeflg) > maxprt;
  181.         /* 4 == strlen(" -> ") */
  182.         if (nprt+4 < maxprt-truncflg-typeflg) {
  183.         expanded++;
  184.         printf(" -> ");
  185.         for (i = nprt + 4, p = linkname(lp);
  186.              len-- && i < maxprt-truncflg-typeflg;
  187.              i++)
  188.             if (isprint(*p))
  189.             (void) putchar(*p++);
  190.             else {
  191.             (void) putchar('?');
  192.             p++;
  193.             }
  194.         }
  195.         if (truncflg)
  196.         (void) putchar('-');
  197.     }
  198.     }
  199. #endif S_IFLNK
  200.     if (typeflg) {
  201.     i = symtype(lp);
  202.     if (expanded && i == '>')   /* we can already tell cause of ->  */
  203.         i = '/';
  204.     (void) putchar(i);
  205.     }
  206. }
  207.  
  208.     /* return a file`s symbolic "type" character */
  209. int
  210. symtype(lp)
  211. register struct lbuf *lp;
  212. {
  213.     register int c;
  214.  
  215.     switch(lp->ltype) {
  216.     case 'd':
  217.         c = '/';
  218.         break;
  219. #ifdef S_IFLNK
  220.     case 'l':
  221.         c = '@';
  222.         break;
  223.     case 'L':
  224.         c = '>';            /* symlink to directory */
  225.         break;
  226. #endif
  227. #ifdef S_IFSOCK
  228.     case 's':
  229.         c = '=';
  230.         break;
  231. #endif
  232.     default:
  233.         if (lp->lmode & S_IEXEC)    /* check owner only */
  234.         c = '*';
  235.         else c = ' ';
  236.         break;
  237.     }
  238.     return c;
  239. }
  240.  
  241. #ifndef UTAH
  242. char *
  243. skipto(string, charset)
  244. register char *string;
  245. char *charset;
  246. {
  247.     register char *setp;
  248.     register int found = 0;        /* not found yet */
  249.  
  250.     while (*string && !found) {    /* until null or found */
  251.         /* find first char in charset matching *string */
  252.         for (setp = charset; *setp && (*setp != *string); setp++)
  253.         continue;
  254.         if (*setp)
  255.         found = 1;        /* matches a char */
  256.         else
  257.         string++;        /* else keep looking */
  258.     }
  259.     return string;
  260. }
  261.  
  262. char *
  263. skipover(string, charset)
  264. register char *string;
  265. char *charset;
  266. {
  267.     register char *setp;
  268.     register int found = 0;        /* not found yet */
  269.  
  270.     while (*string && !found) {    /* until null or found */
  271.         /* find first char in charset matching *string */
  272.         for (setp = charset; *setp && (*setp != *string); setp++)
  273.         continue;
  274.         if (*setp)
  275.         string++;        /* not found yet */
  276.         else
  277.         found = 1;
  278.     }
  279.     return string;
  280. }
  281. #endif UTAH
  282.  
  283. #ifdef notyet
  284. #ifndef xBSD42
  285. /*
  286.  * Convert size to number of "standard blocks".  Do NOT necessarily
  287.  * convert to number of kilobytes (which is itself cleaner), but try to
  288.  * match "ls"s behavior on a given version of Unix.
  289.  */
  290. long
  291. sztob(size)
  292. long    size;
  293. {
  294.     return (size + BUFSIZ-1) / BUFSIZ; /* guess as to blocksize from stdio.h*/
  295. }
  296.  
  297. #else xBSD42
  298. /*
  299.  * Same as sztob, but uses st_blocks field in 4.2 for a
  300.  * more accurate indication. We know 4.2 uses KB, so hardwire it.
  301.  */
  302. #define    kbytes(size)    (((size) + 1023) / 1024)
  303.  
  304. long
  305. stbtok(nblks)
  306. long nblks;
  307. {
  308.     return kbytes(dbtob(nblks));
  309. }
  310. #endif xBSD42
  311. #endif notyet
  312.  
  313. #ifdef unneeded
  314. char *
  315. catargs(str, argv)
  316. char *str;
  317. char *argv[];
  318. {
  319.     for (++argv; *argv; argv++)
  320.     if (**argv == '-') {
  321.         (void) strcat(str, *argv);
  322.         (void) strcat(str, " ");
  323.     }
  324.     return str;
  325. }
  326.  
  327. overflow()
  328. {
  329.     printf("\n?Too many files\007\n");
  330.     sleep(1);        /* So user can see it - don't worry if less */
  331.     exit(1);
  332. }
  333. #endif unneeded
  334.